package com.yidu.action;


import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.yidu.action.vo.ListenModuleManageVo;
import com.yidu.common.JsonMsg;
import com.yidu.common.Pages;
import com.yidu.common.Tools;
import com.yidu.domain.ListenBackstageUser;
import com.yidu.domain.ListenModuleManage;
import com.yidu.service.ListenModuleManageService;
import com.yidu.service.ListenModuleRoleService;
import com.yidu.service.ListenUserRoleService;

/**
 * 
 * 类注释:模块管理前端控制器
 * @author wpy
 * 2018年11月27日上午11:44:40
 */
@Controller
@RequestMapping("/listenModuleManage")
public class ListenModuleManageController {
	
	@Resource
	private ListenModuleManageService moduleManageService;
	
	@Resource
	private ListenUserRoleService userRoleService;
	
	@Resource
	private ListenModuleRoleService moduleRoleService;
	
	/**
	 * 查询模块数据
	 * @param mmName 模块名称
	 * @param mmId	模块id
	 * @param page 当前页数
	 * @param limit 当前行数
	 * @return
	 */
	@RequestMapping("selectModuleManage")
	@ResponseBody
	public Map<String,Object> selectModuleManage(@RequestParam(value = "key[mmName]", required =false)String mmName,@RequestParam(value = "key[mmId]", required =false)String mmId,@RequestParam(value = "page" , required =false)Integer page,@RequestParam(value = "limit" , required =false)Integer limit){
		//创建一个模块对象
		ListenModuleManage moduleManage=new ListenModuleManage();
		//判断传过来的名字参数是否为空
		if(mmName!=null && !"".equals(mmName)) {
			moduleManage.setMmName(mmName);//赋值给新建的模块对象
		}
		//判断传过来的名字参数是否为空
		if(mmId!=null && !"".equals(mmId)) {
			moduleManage.setMmId(mmId);//赋值给新建的模块对象
		}
		//创建一个分页对象
		Pages pages = new Pages();
		//判断传过来的两个参数是否为空
		if(page!=null && limit!=null) {
			//分别赋值
			pages.setCurPage(page);
			pages.setMaxResult(limit);
		}
		//创建一个map集合
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("mmName", moduleManage.getMmName());//加一个模块名字
		map.put("firstRows", pages.getFirstRows());//加一个开始页数
		map.put("maxResult", pages.getMaxResult());//加一个当前页的最大行数
		
		//查询所有模块
		List<ListenModuleManage> list = moduleManageService.selectModuleManage(map);
		//得到所有模块的行数
		int rows= moduleManageService.selectCount(map);
		
		//创建一个layui的map集合
		Map<String,Object> layuiMap =new HashMap<String, Object>();
		//赋值
		layuiMap.put("code", 0);
		layuiMap.put("msg", "");
		layuiMap.put("count",rows);
		layuiMap.put("data", list);
		return layuiMap;
	}
	
	/**
	 * 查询所有模块(单选)
	 * @return
	 */
	@RequestMapping("selectGroup")
	@ResponseBody
	public List<ListenModuleManageVo> selectGroup(){
		//查询没有上级模块的集合
		List<ListenModuleManageVo> list = moduleManageService.selectNoSuperior();
		//查询该模块的下级模块
		for (ListenModuleManageVo vo : list) {
			//根据当前的上级模块查询
			List<ListenModuleManageVo> listVo = moduleManageService.selectSubordinate(vo.getId());
			//将查询出来的集合放入上级模块中
			vo.setChildren(listVo);
			vo.setData(listVo);
		}
		return list;
	}
	
	/**
	 * 根据模块id删除(修改是否有效)模块数据
	 * @param mmId 模块id
	 * @return
	 */
	@RequestMapping("deleteModuleManage")
	@ResponseBody
	public JsonMsg deleteModuleManage(String mmId) {
		//创建工具提示类
		JsonMsg msg = new JsonMsg();
		//创建模块类
		ListenModuleManage moduleManage = new ListenModuleManage();
		//判断参数是否为空
		if(mmId!=null && !"".equals(mmId)) {
			//将模块id赋值给对象
			moduleManage.setMmId(mmId);
		}
		//赋值给对象是否有效改为无效
		moduleManage.setIsva(0);
		//调用根据模块对象修改的方法
		int rows = moduleManageService.updateByPrimaryKeySelective(moduleManage);
		//判断是否删除成功(修改为无效)
		if(rows>-1) {
			msg.setDatas(1);
			//修改为无效成功
			msg.setMsg("删除模块成功!");
		}else {
			msg.setDatas(0);
			//修改为无效失败
			msg.setMsg("删除模块失败!");
		}
		return msg;
	}
	
	/**
	 * 根据模块id查询模块数据
	 * @param mmId 模块id
	 * @return
	 */
	@RequestMapping("findById")
	@ResponseBody
	public ListenModuleManageVo findById(String mmId){
		//定义模块vo对象
		ListenModuleManageVo vo = null;
		//判断模块id是否为空
		if(mmId!=null && !"".equals(mmId)) {
			//根据id查询赋值给vo
			vo = moduleManageService.selectByPrimaryKey(mmId);
		}
		return vo;
	}
	
	/**
	 * 增加或修改模块
	 * @param request 请求
	 * @param moduleManage 模块对象
	 * @param lismmId 上级模块id
	 * @return
	 */
	@RequestMapping("insertOrUpdate")
	@ResponseBody
	public JsonMsg insertOrUpdate(HttpServletRequest request,ListenModuleManage moduleManage,String lismmId) {
		//得到会话
		HttpSession session = request.getSession();
		//得到用户
		ListenBackstageUser user = (ListenBackstageUser) session.getAttribute("user");
		//判断上级模块id不为空时
		if(lismmId!=null && !"null".equals(lismmId) && !"undefined".equals(lismmId)) {
			//将上级模块赋值模块对象
			moduleManage.setLisMmId(lismmId);
		}else {
			//将上级模块设置为根模块赋值给模块对象
			moduleManage.setLisMmId("0");
		}
		//创建工具类
		JsonMsg msg = new JsonMsg();
		//判断传过来的模块对象是否为空
		if(moduleManage!=null) {
			//默认为有效数据
			moduleManage.setIsva(1);
			//操作时间 (系统时间)
			moduleManage.setOpenTime(new Date());
			//判断用户是否为空
			if(user!=null) {
				//操作人为当前登陆后台人的姓名
				moduleManage.setOper(user.getBuName());
			}
			//判断模型对象中的主键是否为空
			if(moduleManage.getMmId()!=null && !"".equals(moduleManage.getMmId())) {
				//根据对象修改已有的模块数据
				int rows = moduleManageService.updateByPrimaryKeySelective(moduleManage);
				if(rows>-1) {
					msg.setDatas(1);
					msg.setMsg("修改模块成功");
				}else {
					msg.setDatas(2);
					msg.setMsg("修改模块失败");
				}
			}else {
				//id随机码
				moduleManage.setMmId(Tools.getRandomString());
				//根据对象增加已有的模块数据
				int rows = moduleManageService.insertSelective(moduleManage);
				if(rows>-1) {
					msg.setDatas(1);
					msg.setMsg("增加模块成功");
				}else {
					msg.setDatas(2);
					msg.setMsg("增加模块失败");
				}
			}
		}
		return msg;
	}
	
	/**
	 * 根据用户id查询所拥有的权限
	 * @param userId 用户id
	 * @return
	 */
	@RequestMapping("selectUserManage")
	@ResponseBody
	public  List<ListenModuleManage>  selectUserManage(String userId){
		//根据用户id查询角色选中的模块
		List<ListenModuleManage> list = moduleManageService.selectUserModuleManage(userId);
		//去重复
		//(集合第一次)
		for (int i = 0; i < list.size() - 1; i++) {
			//(集合第二次)
            for (int j = list.size() - 1; j > i; j--) {
            	//判断如果第一次集合的模块id等于第二次集合的模块id
                if (list.get(j).getMmId().equals(list.get(i).getMmId())) {
                	//移除第二个集合
                    list.remove(j);
                }
            }
		}
		return list;
	}
}

